package org.apache.maven.lifecycle.internal;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.maven.execution.ExecutionEvent;
import org.apache.maven.execution.MavenExecutionRequest;
import org.apache.maven.execution.MavenExecutionResult;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.lifecycle.DefaultLifecycles;
import org.apache.maven.lifecycle.MissingProjectException;
import org.apache.maven.lifecycle.NoGoalSpecifiedException;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
import org.codehaus.plexus.logging.Logger;

import java.util.List;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Starts the build life cycle
 * 
 * @author Jason van Zyl
 * @author Benjamin Bentmann
 * @author Kristian Rosenvold
 */
@Component(role = LifecycleStarter.class)
public class LifecycleStarter {

  @Requirement
  private ExecutionEventCatapult eventCatapult;

  @Requirement
  private DefaultLifecycles defaultLifeCycles;

  @Requirement
  private Logger logger;

  @Requirement
  private LifecycleModuleBuilder lifecycleModuleBuilder;

  @Requirement
  private LifecycleWeaveBuilder lifeCycleWeaveBuilder;

  @Requirement
  private LifecycleThreadedBuilder lifecycleThreadedBuilder;

  @Requirement
  private BuildListCalculator buildListCalculator;

  @Requirement
  private LifecycleDebugLogger lifecycleDebugLogger;

  @Requirement
  private LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator;

  @Requirement
  private ThreadConfigurationService threadConfigService;

  public void execute(MavenSession session) {
    eventCatapult.fire(ExecutionEvent.Type.SessionStarted, session, null);

    MavenExecutionResult result = session.getResult();

    try {
      if (!session.isUsingPOMsFromFilesystem() && lifecycleTaskSegmentCalculator.requiresProject(session)) {
        throw new MissingProjectException("The goal you specified requires a project to execute"
            + " but there is no POM in this directory (" + session.getExecutionRootDirectory() + ")."
            + " Please verify you invoked Maven from the correct directory.");
      }

      final MavenExecutionRequest executionRequest = session.getRequest();
      boolean isThreaded = executionRequest.isThreadConfigurationPresent();
      session.setParallel(isThreaded);

      List<TaskSegment> taskSegments = lifecycleTaskSegmentCalculator.calculateTaskSegments(session);

      ProjectBuildList projectBuilds = buildListCalculator.calculateProjectBuilds(session, taskSegments);

      if (projectBuilds.isEmpty()) {
        throw new NoGoalSpecifiedException("No goals have been specified for this build."
            + " You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or"
            + " <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>." + " Available lifecycle phases are: "
            + defaultLifeCycles.getLifecyclePhaseList() + ".");
      }

      ProjectIndex projectIndex = new ProjectIndex(session.getProjects());

      if (logger.isDebugEnabled()) {
        lifecycleDebugLogger.debugReactorPlan(projectBuilds);
      }

      ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();

      ReactorBuildStatus reactorBuildStatus = new ReactorBuildStatus(session.getProjectDependencyGraph());
      ReactorContext callableContext = new ReactorContext(result, projectIndex, oldContextClassLoader,
          reactorBuildStatus);

      if (isThreaded) {
        ExecutorService executor = threadConfigService.getExecutorService(executionRequest.getThreadCount(),
            executionRequest.isPerCoreThreadCount(), session.getProjects().size());
        try {

          final boolean isWeaveMode = LifecycleWeaveBuilder.isWeaveMode(executionRequest);
          if (isWeaveMode) {
            lifecycleDebugLogger.logWeavePlan(session);
            lifeCycleWeaveBuilder.build(projectBuilds, callableContext, taskSegments, session, executor,
                reactorBuildStatus);
          } else {
            ConcurrencyDependencyGraph analyzer = new ConcurrencyDependencyGraph(projectBuilds,
                session.getProjectDependencyGraph());

            CompletionService<ProjectSegment> service = new ExecutorCompletionService<ProjectSegment>(executor);

            lifecycleThreadedBuilder.build(session, callableContext, projectBuilds, taskSegments, analyzer, service);
          }
        } finally {
          executor.shutdown();
          // If the builder has terminated with an exception we want to catch any stray threads
          // before going
          // to System.exit in the mavencli.
          executor.awaitTermination(5, TimeUnit.SECONDS);
        }
      } else {
        singleThreadedBuild(session, callableContext, projectBuilds, taskSegments, reactorBuildStatus);
      }

    } catch (Exception e) {
      result.addException(e);
    }

    eventCatapult.fire(ExecutionEvent.Type.SessionEnded, session, null);
  }

  private void singleThreadedBuild(MavenSession session, ReactorContext callableContext, ProjectBuildList projectBuilds,
      List<TaskSegment> taskSegments, ReactorBuildStatus reactorBuildStatus) {
    for (TaskSegment taskSegment : taskSegments) {
      for (ProjectSegment projectBuild : projectBuilds.getByTaskSegment(taskSegment)) {
        try {
          lifecycleModuleBuilder.buildProject(session, callableContext, projectBuild.getProject(), taskSegment);
          if (reactorBuildStatus.isHalted()) {
            break;
          }
        } catch (Exception e) {
          break;  // Why are we just ignoring this exception? Are exceptions are being used for flow
                  // control
        }

      }
    }
  }
}
